93 research outputs found
AsmetaF: A Flattener for the ASMETA Framework
Abstract State Machines (ASMs) have shown to be a suitable high-level
specification method for complex, even industrial, systems; the ASMETA
framework, supporting several validation and verification activities on ASM
models, is an example of a formal integrated development environment. Although
ASMs allow modeling complex systems in a rather concise way -and this is
advantageous for specification purposes-, such concise notation is in general a
problem for verification activities as model checking and theorem proving that
rely on tools accepting simpler notations.
In this paper, we propose a flattener tool integrated in the ASMETA framework
that transforms a general ASM model in a flattened model constituted only of
update, parallel, and conditional rules; such model is easier to map to
notations of verification tools. Experiments show the effect of applying the
tool to some representative case studies of the ASMETA repository.Comment: In Proceedings F-IDE 2018, arXiv:1811.09014. The first two authors
are supported by ERATO HASUO Metamathematics for Systems Design Project (No.
JPMJER1603), JST. Funding Reference number: 10.13039/501100009024 ERAT
Towards Quantum Software Requirements Engineering
Quantum software engineering (QSE) is receiving increasing attention, as
evidenced by increasing publications on topics, e.g., quantum software
modeling, testing, and debugging. However, in the literature, quantum software
requirements engineering (QSRE) is still a software engineering area that is
relatively less investigated. To this end, in this paper, we provide an initial
set of thoughts about how requirements engineering for quantum software might
differ from that for classical software after making an effort to map classical
requirements classifications (e.g., functional and extra-functional
requirements) into the context of quantum software. Moreover, we provide
discussions on various aspects of QSRE that deserve attention from the quantum
software engineering community
User-driven geo-temporal density-based exploration of periodic and not periodic events reported in social networks
International audienceIn this paper we propose a procedure consisting of a first collection phase of social net- work messages, a subsequent user query selection, and finally a clustering phase, de- fined by extending the density-based DBSCAN algorithm, for performing a geographic and temporal exploration of a collection of items, in order to reveal and map their latent spatio-temporal structure. Specifically, both several geo-temporal distance measures and a density-based geo-temporal clustering algorithm are proposed. The approach can be applied to social messages containing an explicit geographic and temporal location. The algorithm usage is exemplified to identify geographic regions where many geotagged Twitter messages about an event of interest have been created, possibly in the same time period in the case of non-periodic events (aperiodic events), or at regular timestamps in the case of periodic events. This allows discovering the spatio-temporal periodic and aperiodic characteristics of events occurring in specific geographic areas, and thus increasing the awareness of decision makers who are in charge of territorial planning. Several case studies are used to illustrate the proposed procedure
Online Causation Monitoring of Signal Temporal Logic
Online monitoring is an effective validation approach for hybrid systems,
that, at runtime, checks whether the (partial) signals of a system satisfy a
specification in, e.g., Signal Temporal Logic (STL). The classic STL monitoring
is performed by computing a robustness interval that specifies, at each
instant, how far the monitored signals are from violating and satisfying the
specification. However, since a robustness interval monotonically shrinks
during monitoring, classic online monitors may fail in reporting new violations
or in precisely describing the system evolution at the current instant. In this
paper, we tackle these issues by considering the causation of violation or
satisfaction, instead of directly using the robustness. We first introduce a
Boolean causation monitor that decides whether each instant is relevant to the
violation or satisfaction of the specification. We then extend this monitor to
a quantitative causation monitor that tells how far an instant is from being
relevant to the violation or satisfaction. We further show that classic
monitors can be derived from our proposed ones. Experimental results show that
the two proposed monitors are able to provide more detailed information about
system evolution, without requiring a significantly higher monitoring cost.Comment: 31 pages, 7 figures, the full version of the paper accepted by CAV
202
Noise-Aware Quantum Software Testing
Quantum Computing (QC) promises computational speedup over classic computing
for solving some complex problems. However, noise exists in current and
near-term quantum computers. Quantum software testing (for gaining confidence
in quantum software's correctness) is inevitably impacted by noise, to the
extent that it is impossible to know if a test case failed due to noise or real
faults. Existing testing techniques test quantum programs without considering
noise, i.e., by executing tests on ideal quantum computer simulators.
Consequently, they are not directly applicable to testing quantum software on
real QC hardware or noisy simulators. To this end, we propose a noise-aware
approach (named QOIN) to alleviate the noise effect on test results of quantum
programs. QOIN employs machine learning techniques (e.g., transfer learning) to
learn the noise effect of a quantum computer and filter it from a quantum
program's outputs. Such filtered outputs are then used as the input to perform
test case assessments (determining the passing or failing of a test case
execution against a test oracle). We evaluated QOIN on IBM's 23 noise models
with nine real-world quantum programs and 1000 artificial quantum programs. We
also generated faulty versions of these programs to check if a failing test
case execution can be determined under noise. Results show that QOIN can reduce
the noise effect by more than . To check QOIN's effectiveness for quantum
software testing, we used an existing test oracle for quantum software testing.
The results showed that the F1-score of the test oracle was improved on average
by for six real-world programs and by for 800 artificial
programs, demonstrating that QOIN can effectively learn noise patterns and
enable noise-aware quantum software testing
QuCAT: A Combinatorial Testing Tool for Quantum Software
With the increased developments in quantum computing, the availability of
systematic and automatic testing approaches for quantum programs is becoming
increasingly essential. To this end, we present the quantum software testing
tool QuCAT for combinatorial testing of quantum programs. QuCAT provides two
functionalities of use. With the first functionality, the tool generates a test
suite of a given strength (e.g., pair-wise). With the second functionality, it
generates test suites with increasing strength until a failure is triggered or
a maximum strength is reached. QuCAT uses two test oracles to check the
correctness of test outputs. We assess the cost and effectiveness of QuCAT with
3 faulty versions of 5 quantum programs. Results show that combinatorial test
suites with a low strength can find faults with limited cost, while a higher
strength performs better to trigger some difficult faults with relatively
higher cost. Repository: https://github.com/Simula-COMPLEX/qucat-tool Video:
https://youtu.be/UsqgOudKLi
Using a Variational Autoencoder to Learn Valid Search Spaces of Safely Monitored Autonomous Robots for Last-Mile Delivery
The use of autonomous robots for delivery of goods to customers is an exciting new way to provide a reliable and sustainable service. However, in the real world, autonomous robots still require human supervision for safety reasons. We tackle the real-world problem of optimizing autonomous robot timings to maximize deliveries, while ensuring that there are never too many robots running simultaneously so that they can be monitored safely. We assess the use of a recent hybrid machine-learning-optimization approach COIL (constrained optimization in learned latent space) and compare it with a baseline genetic algorithm for the purposes of exploring variations of this problem. We also investigate new methods for improving the speed and efficiency of COIL. We show that only COIL can find valid solutions where appropriate numbers of robots run simultaneously for all problem variations tested. We also show that when COIL has learned its latent representation, it can optimize 10% faster than the GA, making it a good choice for daily re-optimization of robots where delivery requests for each day are allocated to robots while maintaining safe numbers of robots running at once
Improving mobile user interface testing with model driven monkey search
Testing mobile applications often relies on tools, such
as Exerciser Monkey for Android systems, that simulate user
input. Exerciser Monkey, for example, generates random events
(e.g., touches, gestures, navigational keys) that give developers a
sense of what their application will do when deployed on real
mobile phones with real users interacting with it. These tools,
however, have no knowledge of the underlying applicationsâ structures and only interact with them randomly or in a predefined
manner (e.g., if developers designed scenarios, a labour-intensive
task) â making them slow and poor at finding bugs.
In this paper, we propose a novel control flow structure able
to represent the code of Android applications, including all the
interactive elements. We show that our structure can increase
the effectiveness (higher coverage) and efficiency (removing
duplicate/redundant tests) of the Exerciser Monkey by giving it
knowledge of the test environment. We compare the interface
coverage achieved by the Exerciser Monkey with our new
Monkey++ using a depth first search of our control flow structure
and show that while the random nature of Exerciser Monkey
creates slow test suites of poor coverage, the test suite created
by a depth first search is one order of magnitude faster and
achieves full coverage of the user interaction elements. We believe
this research will lead to a more effective and efficient Exerciser
Monkey, as well as better targeted search based techniques for
automated Android testing
- âŠ